"""
Interactive Agent - 交互式视频生成系统
支持用户在关键步骤进行干预、编辑和优化
"""

import os
import json
from typing import List, Dict, Optional
from pathlib import Path


class Colors:
    """终端颜色代码"""
    HEADER = '\033[95m'
    BLUE = '\033[94m'
    CYAN = '\033[96m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'
    END = '\033[0m'


class InteractiveAgent:
    """交互式代理 - 提供用户交互功能"""
    
    def __init__(self):
        self.history = []  # 记录所有交互历史
    
    def print_header(self, text: str):
        """打印标题"""
        print(f"\n{Colors.BOLD}{Colors.CYAN}{'='*70}{Colors.END}")
        print(f"{Colors.BOLD}{Colors.CYAN}{text.center(70)}{Colors.END}")
        print(f"{Colors.BOLD}{Colors.CYAN}{'='*70}{Colors.END}\n")
    
    def print_section(self, text: str):
        """打印章节"""
        print(f"\n{Colors.BOLD}{Colors.BLUE}{'─'*70}{Colors.END}")
        print(f"{Colors.BOLD}{Colors.BLUE}{text}{Colors.END}")
        print(f"{Colors.BOLD}{Colors.BLUE}{'─'*70}{Colors.END}\n")
    
    def print_success(self, text: str):
        """打印成功信息"""
        print(f"{Colors.GREEN}✅ {text}{Colors.END}")
    
    def print_warning(self, text: str):
        """打印警告信息"""
        print(f"{Colors.YELLOW}⚠️  {text}{Colors.END}")
    
    def print_error(self, text: str):
        """打印错误信息"""
        print(f"{Colors.RED}❌ {text}{Colors.END}")
    
    def print_info(self, text: str):
        """打印信息"""
        print(f"{Colors.CYAN}ℹ️  {text}{Colors.END}")
    
    def get_input(self, prompt: str, default: str = "") -> str:
        """获取用户输入"""
        if default:
            user_input = input(f"{Colors.BOLD}{prompt} [{default}]: {Colors.END}").strip()
            return user_input if user_input else default
        else:
            return input(f"{Colors.BOLD}{prompt}: {Colors.END}").strip()
    
    def get_yes_no(self, prompt: str, default: bool = True) -> bool:
        """获取是/否选择"""
        default_str = "Y/n" if default else "y/N"
        response = self.get_input(f"{prompt} ({default_str})", "y" if default else "n").lower()
        return response in ['y', 'yes', '是'] if response else default
    
    def get_choice(self, prompt: str, choices: List[str], default: int = 0) -> int:
        """获取多选一"""
        print(f"\n{Colors.BOLD}{prompt}{Colors.END}")
        for i, choice in enumerate(choices, 1):
            marker = "→" if i - 1 == default else " "
            print(f"  {marker} {i}. {choice}")
        
        while True:
            response = self.get_input("请选择", str(default + 1))
            try:
                choice_idx = int(response) - 1
                if 0 <= choice_idx < len(choices):
                    return choice_idx
                else:
                    self.print_error(f"请输入 1-{len(choices)} 之间的数字")
            except ValueError:
                self.print_error("请输入有效的数字")
    
    def review_and_edit_pages(self, pages: List[str]) -> List[str]:
        """
        预览并编辑故事页面
        
        Args:
            pages: 故事页面列表
        
        Returns:
            编辑后的页面列表
        """
        self.print_header("📖 故事内容预览与编辑")
        
        edited_pages = pages.copy()
        
        # 首先展示所有页面
        self.print_section("当前故事内容")
        for i, page in enumerate(pages, 1):
            print(f"\n{Colors.BOLD}第 {i} 页:{Colors.END}")
            print(f"{Colors.CYAN}{page}{Colors.END}")
        
        # 询问是否需要编辑
        if not self.get_yes_no("\n是否需要编辑故事内容？", False):
            self.print_success("保持原故事内容")
            return edited_pages
        
        # 逐页编辑
        while True:
            choices = [
                f"编辑第 {i} 页" for i in range(1, len(edited_pages) + 1)
            ] + ["添加新页面", "删除页面", "重新排序", "完成编辑"]
            
            choice_idx = self.get_choice("\n请选择操作", choices, len(choices) - 1)
            
            if choice_idx < len(edited_pages):
                # 编辑特定页面
                page_idx = choice_idx
                self.print_section(f"编辑第 {page_idx + 1} 页")
                print(f"{Colors.YELLOW}原内容:{Colors.END}")
                print(edited_pages[page_idx])
                print(f"\n{Colors.CYAN}请输入新内容（直接回车保持不变，输入 'regen' 使用AI重新生成）:{Colors.END}")
                new_content = input().strip()
                
                if new_content and new_content != 'regen':
                    edited_pages[page_idx] = new_content
                    self.print_success(f"第 {page_idx + 1} 页已更新")
                elif new_content == 'regen':
                    self.print_info("AI重新生成功能需要LLM支持（待实现）")
                
            elif choice_idx == len(edited_pages):
                # 添加新页面
                self.print_section("添加新页面")
                new_page = input(f"{Colors.CYAN}请输入新页面内容: {Colors.END}").strip()
                if new_page:
                    edited_pages.append(new_page)
                    self.print_success(f"已添加第 {len(edited_pages)} 页")
            
            elif choice_idx == len(edited_pages) + 1:
                # 删除页面
                if len(edited_pages) <= 1:
                    self.print_error("至少需要保留1页内容")
                    continue
                page_to_delete = int(self.get_input(f"请输入要删除的页码 (1-{len(edited_pages)})", "0"))
                if 1 <= page_to_delete <= len(edited_pages):
                    deleted = edited_pages.pop(page_to_delete - 1)
                    self.print_success(f"已删除第 {page_to_delete} 页")
                else:
                    self.print_error("无效的页码")
            
            elif choice_idx == len(edited_pages) + 2:
                # 重新排序
                self.print_section("重新排序")
                for i, page in enumerate(edited_pages, 1):
                    print(f"{i}. {page[:50]}...")
                self.print_info("功能待实现：可以拖拽排序")
            
            else:
                # 完成编辑
                break
        
        # 显示最终结果
        self.print_section("编辑后的故事")
        for i, page in enumerate(edited_pages, 1):
            print(f"\n{Colors.BOLD}第 {i} 页:{Colors.END}")
            print(f"{Colors.GREEN}{page}{Colors.END}")
        
        self.print_success(f"故事编辑完成！共 {len(edited_pages)} 页")
        return edited_pages
    
    def review_and_edit_prompts(self, prompts: List[str], pages: List[str]) -> List[str]:
        """
        预览并编辑图像提示词
        
        Args:
            prompts: 原始提示词列表
            pages: 对应的故事页面
        
        Returns:
            编辑后的提示词列表
        """
        self.print_header("🎨 图像提示词预览与优化")
        
        edited_prompts = prompts.copy()
        
        # 展示所有提示词
        self.print_section("当前图像提示词")
        for i, (page, prompt) in enumerate(zip(pages, prompts), 1):
            print(f"\n{Colors.BOLD}第 {i} 页:{Colors.END}")
            print(f"{Colors.CYAN}故事: {page[:60]}...{Colors.END}")
            print(f"{Colors.YELLOW}提示词: {prompt}{Colors.END}")
        
        # 询问是否编辑
        if not self.get_yes_no("\n是否需要优化提示词？", False):
            self.print_success("保持原提示词")
            return edited_prompts
        
        # 逐个编辑
        while True:
            choices = [
                f"优化第 {i} 页提示词" for i in range(1, len(edited_prompts) + 1)
            ] + ["批量添加风格关键词", "完成优化"]
            
            choice_idx = self.get_choice("\n请选择操作", choices, len(choices) - 1)
            
            if choice_idx < len(edited_prompts):
                # 编辑特定提示词
                prompt_idx = choice_idx
                self.print_section(f"优化第 {prompt_idx + 1} 页提示词")
                print(f"{Colors.YELLOW}原提示词:{Colors.END}")
                print(edited_prompts[prompt_idx])
                print(f"\n{Colors.CYAN}请输入新提示词（直接回车保持不变）:{Colors.END}")
                new_prompt = input().strip()
                
                if new_prompt:
                    edited_prompts[prompt_idx] = new_prompt
                    self.print_success(f"第 {prompt_idx + 1} 页提示词已更新")
            
            elif choice_idx == len(edited_prompts):
                # 批量添加关键词
                self.print_section("批量添加风格关键词")
                keywords = self.get_input("请输入要添加的关键词（用逗号分隔）", "")
                if keywords:
                    for i in range(len(edited_prompts)):
                        edited_prompts[i] = f"{edited_prompts[i]}, {keywords}"
                    self.print_success(f"已为所有提示词添加关键词: {keywords}")
            
            else:
                # 完成编辑
                break
        
        self.print_success("提示词优化完成！")
        return edited_prompts
    
    def review_images_and_select_regenerate(self, image_paths: List[str], pages: List[str]) -> List[int]:
        """
        预览生成的图像，选择需要重新生成的
        
        Args:
            image_paths: 图像路径列表
            pages: 故事页面列表
        
        Returns:
            需要重新生成的图像索引列表
        """
        self.print_header("🖼️ 图像预览与重新生成")
        
        # 显示图像信息
        self.print_section("已生成的图像")
        for i, (path, page) in enumerate(zip(image_paths, pages), 1):
            # 🔥 修复：处理 None 值
            if path is None:
                success = False
                path_display = f"<未生成>"
            else:
                success = not path.endswith("_error.png") and os.path.exists(path)
                path_display = path
            
            status = f"{Colors.GREEN}✅ 成功{Colors.END}" if success else f"{Colors.RED}❌ 失败{Colors.END}"
            print(f"{i}. {status} - {path_display}")
            print(f"   故事: {page[:60]}...")
        
        # 🔥 修复：检查是否有有效的图片路径
        valid_paths = [p for p in image_paths if p is not None]
        if valid_paths:
            self.print_info("\n提示: 你可以在文件管理器中查看这些图片")
            self.print_info(f"图片目录: {os.path.dirname(valid_paths[0])}")
        else:
            self.print_warning("\n⚠️  没有成功生成的图片")
        
        # 询问是否重新生成
        if not self.get_yes_no("\n是否需要重新生成某些图片？", False):
            return []
        
        # 选择要重新生成的图片
        regenerate_indices = []
        
        while True:
            page_num = self.get_input(
                f"请输入要重新生成的页码 (1-{len(image_paths)})，输入 'done' 完成选择",
                "done"
            )
            
            if page_num.lower() == 'done':
                break
            
            try:
                idx = int(page_num) - 1
                if 0 <= idx < len(image_paths):
                    if idx not in regenerate_indices:
                        regenerate_indices.append(idx)
                        self.print_success(f"已标记第 {idx + 1} 页图片待重新生成")
                    else:
                        self.print_warning(f"第 {idx + 1} 页已在重新生成列表中")
                else:
                    self.print_error(f"请输入 1-{len(image_paths)} 之间的数字")
            except ValueError:
                self.print_error("请输入有效的数字或 'done'")
        
        if regenerate_indices:
            self.print_success(f"共选择 {len(regenerate_indices)} 张图片待重新生成: {[i+1 for i in regenerate_indices]}")
        
        return regenerate_indices
    
    def final_confirmation(self, pages: List[str], image_paths: List[str], video_paths: Optional[List[str]] = None) -> bool:
        """
        最终确认，显示完整内容摘要
        
        Args:
            pages: 故事页面
            image_paths: 图像路径
        
        Returns:
            是否继续合成视频
        """
        self.print_header("📊 最终确认")
        
        # 统计信息
        total_pages = len(pages)
        success_images = sum(1 for p in image_paths if p and not p.endswith("_error.png") and os.path.exists(p))
        video_paths = video_paths or []
        success_videos = sum(1 for v in video_paths if v and os.path.exists(v))
        
        print(f"{Colors.BOLD}内容摘要:{Colors.END}")
        print(f"  📄 故事页面: {total_pages} 页")
        print(f"  🖼️  成功图片: {success_images}/{total_pages} 张")
        if video_paths:
            print(f"  🎞️  成功视频: {success_videos}/{total_pages} 段")
        print(f"  {'✅' if success_images == total_pages else '⚠️'}  图片完成度: {success_images/total_pages*100:.1f}%")
        if video_paths:
            print(f"  {'✅' if success_videos == total_pages else '⚠️'}  视频完成度: {success_videos/total_pages*100:.1f}%")
        
        # 显示简要内容
        print(f"\n{Colors.BOLD}故事预览:{Colors.END}")
        for i, page in enumerate(pages[:3], 1):
            print(f"  {i}. {page[:50]}...")
        if len(pages) > 3:
            print(f"  ... 还有 {len(pages) - 3} 页")
        
        # 显示图片状态
        print(f"\n{Colors.BOLD}图片状态:{Colors.END}")
        failed_images = [i+1 for i, p in enumerate(image_paths) if not p or p.endswith("_error.png") or not os.path.exists(p)]
        if failed_images:
            self.print_warning(f"失败的图片: 第 {failed_images} 页")
        else:
            self.print_success("所有图片生成成功！")
        
        if video_paths:
            failed_videos = [i+1 for i, v in enumerate(video_paths) if not v or not os.path.exists(v)]
            if failed_videos:
                self.print_warning(f"失败的视频: 第 {failed_videos} 页")
            else:
                self.print_success("所有视频片段生成成功！")
        
        # 最终确认
        print()
        return self.get_yes_no("确认以上内容，继续合成视频？", True)
    
    def save_session(self, session_data: Dict, session_dir: Path):
        """
        保存交互会话数据
        
        Args:
            session_data: 会话数据
            session_dir: 会话目录
        """
        session_file = session_dir / "interactive_session.json"
        session_dir.mkdir(parents=True, exist_ok=True)
        
        with open(session_file, 'w', encoding='utf-8') as f:
            json.dump(session_data, f, ensure_ascii=False, indent=2)
        
        self.print_success(f"会话已保存: {session_file}")
    
    def load_session(self, session_dir: Path) -> Optional[Dict]:
        """
        加载之前的会话
        
        Args:
            session_dir: 会话目录
        
        Returns:
            会话数据或None
        """
        session_file = session_dir / "interactive_session.json"
        
        if not session_file.exists():
            return None
        
        try:
            with open(session_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        except Exception as e:
            self.print_error(f"加载会话失败: {e}")
            return None
    
    def show_help(self):
        """显示帮助信息"""
        help_text = """
        交互式视频生成系统 - 帮助文档
        
        主要功能:
        1. 故事内容编辑 - 预览并修改每个故事页面
        2. 提示词优化 - 调整图像生成提示词
        3. 图片重新生成 - 对不满意的图片重新生成
        4. 最终确认 - 预览所有内容后再合成视频
        
        操作提示:
        - 输入数字选择选项
        - Y/n 表示默认选择是
        - 直接回车使用默认值
        - 输入 'help' 显示帮助
        - 输入 'quit' 退出程序
        
        快捷键:
        - Ctrl+C: 中断当前操作
        - Enter: 确认/使用默认值
        """
        print(help_text)


def enable_windows_ansi():
    """启用Windows终端ANSI颜色支持"""
    import platform
    if platform.system() == 'Windows':
        import ctypes
        kernel32 = ctypes.windll.kernel32
        kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)

def advanced_story_editing_menu(self, pages: List[str]) -> List[str]:
    """增强的故事编辑菜单"""
    self.print_header("✨ 高级编辑功能")
    
    edited_pages = pages.copy()
    
    while True:
        choices = [
            "📝 编辑特定页面",
            "🤖 AI 辅助改写",
            "➕ 插入新页面",
            "❌ 删除页面",
            "🔀 调整顺序",
            "💡 获取优化建议",
            "✅ 完成编辑"
        ]
        
        action = self.get_choice("选择操作", choices, len(choices) - 1)
        
        if action == 0:
            # 编辑特定页面
            page_idx = int(self.get_input(f"选择页码 (1-{len(edited_pages)})", "1")) - 1
            if 0 <= page_idx < len(edited_pages):
                self.print_info(f"当前内容: {edited_pages[page_idx]}")
                new_content = input("新内容: ").strip()
                if new_content:
                    edited_pages[page_idx] = new_content
                    self.print_success("已更新")
        
        elif action == 1:
            # AI 辅助改写
            self._ai_rewrite(edited_pages)
        
        elif action == 2:
            # 插入新页面
            pos = int(self.get_input(f"插入位置 (1-{len(edited_pages)+1})", str(len(edited_pages)+1))) - 1
            new_page = input("新页面内容: ").strip()
            if new_page:
                edited_pages.insert(pos, new_page)
                self.print_success(f"已在位置 {pos+1} 插入新页面")
        
        elif action == 3:
            # 删除页面
            if len(edited_pages) <= 1:
                self.print_error("至少需要保留1页")
                continue
            del_idx = int(self.get_input(f"删除页码 (1-{len(edited_pages)})", "1")) - 1
            if 0 <= del_idx < len(edited_pages):
                deleted = edited_pages.pop(del_idx)
                self.print_success(f"已删除: {deleted[:50]}...")
        
        elif action == 4:
            # 调整顺序
            self.print_info("功能开发中...")
        
        elif action == 5:
            # 优化建议
            self._show_optimization_suggestions(edited_pages)
        
        else:
            break
    
    return edited_pages

def sequential_image_generation_menu(self, prompts: List[str], pages: List[str]) -> List[str]:
    """逐张生成图片菜单"""
    self.print_header("🖼️  逐张生成模式")
    
    images = []
    
    for i, prompt in enumerate(prompts):
        self.print_info(f"\n生成第 {i+1}/{len(prompts)} 张图片")
        print(f"提示词: {prompt[:100]}...")
        
        # 这里调用你的图片生成函数
        # image_path = your_generate_function(prompt, i)
        
        # 临时占位
        image_path = f"temp_image_{i+1}.png"
        self.print_success(f"✅ 已生成: {image_path}")
        
        # 用户反馈
        action = self.get_choice(
            "操作选项",
            ["✅ 满意，继续", "🔄 重新生成", "✏️  修改提示词", "⏭️  跳过"],
            0
        )
        
        if action == 0:
            images.append(image_path)
        elif action == 1:
            # 重新生成
            self.print_info("重新生成...")
            images.append(image_path)  # 实际应该重新调用生成
        elif action == 2:
            # 修改提示词
            new_prompt = self.get_input("新提示词", prompt)
            # 用新提示词生成
            images.append(image_path)
        else:
            images.append(None)
    
    return images